home *** CD-ROM | disk | FTP | other *** search
/ Revista do CD-ROM 124 / cd-rom 124.iso / edu / tuxmath / tuxmathscrabble / tuxmathscrabble.exe / asymptopia / Tux.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-16  |  10.9 KB  |  555 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4. import os
  5. import pygame
  6. from pygame.locals import *
  7. from random import random
  8. from Board import *
  9. from Spot import *
  10. from myutil import *
  11. from Tile import *
  12. from Button import *
  13. from Validator import *
  14. from Player import Player
  15.  
  16. class Tux(Player):
  17.     
  18.     def __init__(self, game):
  19.         Player.__init__(self)
  20.         self.game = game
  21.         self.tray = game.tuxtray
  22.         self.LEVEL = game.LEVEL
  23.         self.current_submission_idx = None
  24.         self.triplets = None
  25.         self.doublets = None
  26.         self.singlets = None
  27.         self.operator_doublets = None
  28.         self.operator_singlets = None
  29.         self.triplet_expressions = None
  30.         self.doublet_expressions = None
  31.         self.singlet_expressions = None
  32.         self.wc_doublet_expressions = None
  33.         self.wc_singlet_expressions = None
  34.  
  35.     
  36.     def getStringValues(self):
  37.         str_values = []
  38.         spots = self.tray.get_spots()
  39.         nnumbers = self.game.NNUMBERS
  40.         newspots = []
  41.         for spotidx in range(nnumbers):
  42.             newspots.append(0)
  43.         
  44.         ntrayspots = self.game.NTRAYSPOTS
  45.         while len(spots) > ntrayspots - nnumbers:
  46.             for spot in spots:
  47.                 if spot.getMN()[1] < nnumbers:
  48.                     newspots[spot.getMN()[1]] = spot
  49.                     spots.remove(spot)
  50.                 
  51.             
  52.         for dummy in range(len(newspots)):
  53.             str_values.append(newspots[dummy].guest.str_val)
  54.         
  55.         return str_values
  56.  
  57.     
  58.     def getAllStringValues(self):
  59.         str_values = []
  60.         spots = self.tray.get_spots()
  61.         ntrayspots = self.game.NTRAYSPOTS
  62.         newspots = []
  63.         for spotidx in range(ntrayspots):
  64.             newspots.append(0)
  65.         
  66.         while len(spots) > 0:
  67.             for spot in spots:
  68.                 newspots[spot.getMN()[1]] = spot
  69.                 spots.remove(spot)
  70.             
  71.         for dummy in range(len(newspots)):
  72.             str_values.append(newspots[dummy].guest.str_val)
  73.         
  74.         return str_values
  75.  
  76.     
  77.     def cycle_vals(self, vals):
  78.         tmp = vals.pop()
  79.         vals.insert(int(random() * len(vals)), tmp)
  80.         return vals
  81.  
  82.     
  83.     def get3x2x1x(self, N):
  84.         plets = []
  85.         num_times_cycled = 0
  86.         str_vals = self.getStringValues()
  87.         NumNumbers = 6
  88.         while num_times_cycled < 1000:
  89.             for idx in range(0, NumNumbers - N):
  90.                 i_plet = []
  91.                 s_plet = []
  92.                 for jdx in range(N):
  93.                     i_plet.append(float(str_vals[idx + jdx]))
  94.                 
  95.                 i_plet.sort()
  96.                 for jdx in range(N):
  97.                     s_plet.append(`i_plet[jdx]`)
  98.                 
  99.                 if plets.count(s_plet) == 0:
  100.                     plets.append(s_plet)
  101.                 elif N == 1 and plets.count(s_plet) < str_vals.count(s_plet[0]):
  102.                     plets.append(s_plet)
  103.                 
  104.             
  105.             str_vals = self.cycle_vals(str_vals)
  106.             num_times_cycled = num_times_cycled + 1
  107.         return plets
  108.  
  109.     
  110.     def evaluate(self, expr):
  111.         str = ''
  112.         for idx in range(len(expr)):
  113.             str = str + expr[idx]
  114.         
  115.         
  116.         try:
  117.             val = eval(str)
  118.         except:
  119.             return 0
  120.  
  121.         return val
  122.  
  123.     
  124.     def get3xPermutations(self, tripplet):
  125.         p = [
  126.             [
  127.                 1,
  128.                 2,
  129.                 3],
  130.             [
  131.                 1,
  132.                 3,
  133.                 2],
  134.             [
  135.                 2,
  136.                 1,
  137.                 3],
  138.             [
  139.                 2,
  140.                 3,
  141.                 1],
  142.             [
  143.                 3,
  144.                 1,
  145.                 2],
  146.             [
  147.                 3,
  148.                 2,
  149.                 1]]
  150.         px3 = []
  151.         for pidx in range(len(p)):
  152.             tx3 = []
  153.             for tidx in range(3):
  154.                 tx3.append(tripplet[p[pidx][tidx] - 1])
  155.             
  156.             if px3.count(tx3) == 0:
  157.                 px3.append(tx3)
  158.             
  159.         
  160.         return px3
  161.  
  162.     
  163.     def get2xPermutations(self, doublet):
  164.         p = [
  165.             [
  166.                 1,
  167.                 2],
  168.             [
  169.                 2,
  170.                 1]]
  171.         px2 = []
  172.         for pidx in range(len(p)):
  173.             dx2 = []
  174.             for tidx in range(2):
  175.                 dx2.append(doublet[p[pidx][tidx] - 1])
  176.             
  177.             if px2.count(dx2) == 0:
  178.                 px2.append(dx2)
  179.             
  180.         
  181.         return px2
  182.  
  183.     
  184.     def get_operator_plets(self, N):
  185.         if N == 1:
  186.             plets = [
  187.                 [
  188.                     '+'],
  189.                 [
  190.                     '-'],
  191.                 [
  192.                     '*'],
  193.                 [
  194.                     '/']]
  195.         elif N == 2 and self.LEVEL <= 4:
  196.             plets = [
  197.                 [
  198.                     '+',
  199.                     '+'],
  200.                 [
  201.                     '+',
  202.                     '-'],
  203.                 [
  204.                     '-',
  205.                     '+'],
  206.                 [
  207.                     '-',
  208.                     '-'],
  209.                 [
  210.                     '*',
  211.                     '*'],
  212.                 [
  213.                     '*',
  214.                     '/'],
  215.                 [
  216.                     '/',
  217.                     '*'],
  218.                 [
  219.                     '/',
  220.                     '/'],
  221.                 [
  222.                     '*',
  223.                     '-'],
  224.                 [
  225.                     '-',
  226.                     '*'],
  227.                 [
  228.                     '*',
  229.                     '+'],
  230.                 [
  231.                     '+',
  232.                     '*'],
  233.                 [
  234.                     '/',
  235.                     '-'],
  236.                 [
  237.                     '-',
  238.                     '/'],
  239.                 [
  240.                     '/',
  241.                     '+'],
  242.                 [
  243.                     '+',
  244.                     '/']]
  245.         elif N == 2 and self.LEVEL < 3:
  246.             plets = [
  247.                 [
  248.                     '+',
  249.                     '+'],
  250.                 [
  251.                     '+',
  252.                     '-'],
  253.                 [
  254.                     '-',
  255.                     '+'],
  256.                 [
  257.                     '-',
  258.                     '-']]
  259.         
  260.         return plets
  261.  
  262.     
  263.     def generate_expressions(self):
  264.         triplets = self.get3x2x1x(3)
  265.         doublets = self.get3x2x1x(2)
  266.         singlets = self.get3x2x1x(1)
  267.         operator_doublets = self.get_operator_plets(2)
  268.         operator_singlets = self.get_operator_plets(1)
  269.         current_submission_idx = 0
  270.         triplet_expressions = []
  271.         for pdx in range(0, len(triplets)):
  272.             permutations = self.get3xPermutations(triplets[pdx])
  273.             for perm in permutations:
  274.                 for odx in range(len(operator_doublets)):
  275.                     expr = [
  276.                         perm[0],
  277.                         operator_doublets[odx][0],
  278.                         perm[1],
  279.                         operator_doublets[odx][1],
  280.                         perm[2]]
  281.                     value = self.evaluate(expr)
  282.                     triplet_expressions.append([
  283.                         pdx,
  284.                         odx,
  285.                         expr,
  286.                         value])
  287.                 
  288.             
  289.         
  290.         doublet_expressions = []
  291.         for pdx in range(0, len(doublets)):
  292.             permutations = self.get2xPermutations(doublets[pdx])
  293.             for perm in permutations:
  294.                 for odx in range(len(operator_singlets)):
  295.                     expr = [
  296.                         perm[0],
  297.                         operator_singlets[odx][0],
  298.                         perm[1]]
  299.                     value = self.evaluate(expr)
  300.                     doublet_expressions.append([
  301.                         pdx,
  302.                         odx,
  303.                         expr,
  304.                         value])
  305.                 
  306.             
  307.         
  308.         wc_doublet_expressions = []
  309.         for pdx in range(0, len(singlets)):
  310.             for odx in range(len(operator_singlets)):
  311.                 for val in range(21):
  312.                     expr = [
  313.                         `val` + '.0',
  314.                         operator_singlets[odx][0],
  315.                         singlets[pdx][0]]
  316.                     value = self.evaluate(expr)
  317.                     expr = [
  318.                         'WC:' + `val` + '.0',
  319.                         operator_singlets[odx][0],
  320.                         singlets[pdx][0]]
  321.                     wc_doublet_expressions.append([
  322.                         pdx,
  323.                         odx,
  324.                         expr,
  325.                         value])
  326.                 
  327.             
  328.         
  329.         for pdx in range(0, len(singlets)):
  330.             for odx in range(len(operator_singlets)):
  331.                 for val in range(21):
  332.                     expr = [
  333.                         singlets[pdx][0],
  334.                         operator_singlets[odx][0],
  335.                         `val` + '.0']
  336.                     value = self.evaluate(expr)
  337.                     expr = [
  338.                         singlets[pdx][0],
  339.                         operator_singlets[odx][0],
  340.                         'WC:' + `val` + '.0']
  341.                     wc_doublet_expressions.append([
  342.                         pdx,
  343.                         odx,
  344.                         expr,
  345.                         value])
  346.                 
  347.             
  348.         
  349.         for pdx in range(0, len(doublets)):
  350.             permutations = self.get2xPermutations(doublets[pdx])
  351.             for perm in permutations:
  352.                 for odx in range(len(operator_singlets)):
  353.                     expr = [
  354.                         perm[0],
  355.                         operator_singlets[odx][0],
  356.                         perm[1]]
  357.                     value = self.evaluate(expr)
  358.                     expr = [
  359.                         perm[0],
  360.                         'WC:' + operator_singlets[odx][0],
  361.                         perm[1]]
  362.                     wc_doublet_expressions.append([
  363.                         pdx,
  364.                         odx,
  365.                         expr,
  366.                         value])
  367.                 
  368.             
  369.         
  370.         wc_wc_doublet_expressions = []
  371.         for v1 in range(21):
  372.             for v2 in range(21):
  373.                 for odx in range(len(operator_singlets)):
  374.                     expr = [
  375.                         `v1` + '.0',
  376.                         operator_singlets[odx][0],
  377.                         `v2` + '.0']
  378.                     value = self.evaluate(expr)
  379.                     expr = [
  380.                         'WC:' + `v1` + '.0',
  381.                         operator_singlets[odx][0],
  382.                         'WC:' + `v2` + '.0']
  383.                     wc_wc_doublet_expressions.append([
  384.                         0,
  385.                         odx,
  386.                         expr,
  387.                         value])
  388.                 
  389.             
  390.         
  391.         singlet_expressions = []
  392.         for pdx in range(0, len(singlets)):
  393.             expr = [
  394.                 singlets[pdx][0]]
  395.             value = self.evaluate(expr[0])
  396.             singlet_expressions.append([
  397.                 pdx,
  398.                 None,
  399.                 expr,
  400.                 value])
  401.         
  402.         wc_singlet_expressions = []
  403.         for pdx in range(0, 21):
  404.             expr = [
  405.                 'WC:' + `pdx` + '.0']
  406.             value = pdx
  407.             wc_singlet_expressions.append([
  408.                 pdx,
  409.                 None,
  410.                 expr,
  411.                 value])
  412.         
  413.         self.triplet_expressions = triplet_expressions
  414.         self.doublet_expressions = doublet_expressions
  415.         self.singlet_expressions = singlet_expressions
  416.         self.wc_doublet_expressions = wc_doublet_expressions
  417.         self.wc_wc_doublet_expressions = wc_wc_doublet_expressions
  418.         self.wc_singlet_expressions = wc_singlet_expressions
  419.         self.game.do_one_scratch()
  420.  
  421.     
  422.     def construct_submission(self, lhs_expressions, rhs_expressions):
  423.         stringValues = self.getAllStringValues()
  424.         self.game.do_one_scratch()
  425.         for idx1 in range(len(lhs_expressions)):
  426.             for idx2 in range(len(rhs_expressions)):
  427.                 if lhs_expressions[idx1][3] == rhs_expressions[idx2][3]:
  428.                     combinedList = []
  429.                     for idx in range(len(lhs_expressions[idx1][2])):
  430.                         combinedList.append(lhs_expressions[idx1][2][idx])
  431.                     
  432.                     combinedList.append('=')
  433.                     for idx in range(len(rhs_expressions[idx2][2])):
  434.                         combinedList.append(rhs_expressions[idx2][2][idx])
  435.                     
  436.                     ok = 1
  437.                     for elem in combinedList:
  438.                         count = combinedList.count(elem)
  439.                         if elem.count('WC:'):
  440.                             pass
  441.                         elif stringValues.count(elem) < count:
  442.                             ok = 0
  443.                         
  444.                     
  445.                     if ok == 1:
  446.                         rlist = self.game.localizer.localize(combinedList)
  447.                         if rlist:
  448.                             return rlist
  449.                         
  450.                     
  451.                 
  452.             
  453.         
  454.         return None
  455.  
  456.     
  457.     def generate_options(self):
  458.         triplet_expressions = self.triplet_expressions
  459.         doublet_expressions = self.doublet_expressions
  460.         singlet_expressions = self.singlet_expressions
  461.         wc_doublet_expressions = self.wc_doublet_expressions
  462.         wc_wc_doublet_expressions = self.wc_wc_doublet_expressions
  463.         wc_singlet_expressions = self.wc_singlet_expressions
  464.         operator_doublets = self.operator_doublets
  465.         operator_singlets = self.operator_singlets
  466.         LEVEL = self.LEVEL
  467.         self.options = []
  468.         tray = self.tray
  469.         spots = self.tray.get_spots()
  470.         self.game.localizer.update_board_map()
  471.         num_commited = self.game.board.get_num_commited()
  472.         if num_commited > 3 and LEVEL > 1:
  473.             rlist = self.construct_submission(triplet_expressions, wc_doublet_expressions)
  474.             if rlist:
  475.                 return rlist
  476.             
  477.             rlist = self.construct_submission(wc_doublet_expressions, triplet_expressions)
  478.             if rlist:
  479.                 return rlist
  480.             
  481.             rlist = self.construct_submission(triplet_expressions, wc_singlet_expressions)
  482.             if rlist:
  483.                 return rlist
  484.             
  485.             rlist = self.construct_submission(wc_singlet_expressions, triplet_expressions)
  486.             if rlist:
  487.                 return rlist
  488.             
  489.         
  490.         if num_commited > 3:
  491.             rlist = self.construct_submission(doublet_expressions, wc_wc_doublet_expressions)
  492.             if rlist:
  493.                 return rlist
  494.             
  495.             rlist = self.construct_submission(wc_wc_doublet_expressions, doublet_expressions)
  496.             if rlist:
  497.                 return rlist
  498.             
  499.             rlist = self.construct_submission(wc_wc_doublet_expressions, singlet_expressions)
  500.             if rlist:
  501.                 return rlist
  502.             
  503.             rlist = self.construct_submission(singlet_expressions, wc_wc_doublet_expressions)
  504.             if rlist:
  505.                 return rlist
  506.             
  507.             rlist = self.construct_submission(wc_doublet_expressions, wc_doublet_expressions)
  508.             if rlist:
  509.                 return rlist
  510.             
  511.             rlist = self.construct_submission(doublet_expressions, wc_doublet_expressions)
  512.             if rlist:
  513.                 return rlist
  514.             
  515.             rlist = self.construct_submission(wc_doublet_expressions, doublet_expressions)
  516.             if rlist:
  517.                 return rlist
  518.             
  519.         
  520.         rlist = self.construct_submission(wc_singlet_expressions, wc_doublet_expressions)
  521.         if rlist:
  522.             return rlist
  523.         
  524.         rlist = self.construct_submission(wc_doublet_expressions, wc_singlet_expressions)
  525.         if rlist:
  526.             return rlist
  527.         
  528.         rlist = self.construct_submission(doublet_expressions, wc_singlet_expressions)
  529.         if rlist:
  530.             return rlist
  531.         
  532.         rlist = self.construct_submission(wc_singlet_expressions, doublet_expressions)
  533.         if rlist:
  534.             return rlist
  535.         
  536.         rlist = self.construct_submission(singlet_expressions, wc_doublet_expressions)
  537.         if rlist:
  538.             return rlist
  539.         
  540.         rlist = self.construct_submission(wc_doublet_expressions, singlet_expressions)
  541.         if rlist:
  542.             return rlist
  543.         
  544.         rlist = self.construct_submission(wc_singlet_expressions, singlet_expressions)
  545.         if rlist:
  546.             return rlist
  547.         
  548.         rlist = self.construct_submission(singlet_expressions, wc_singlet_expressions)
  549.         if rlist:
  550.             return rlist
  551.         else:
  552.             return None
  553.  
  554.  
  555.